返回博客列表

Python 数据结构：列表、元组、字典与集合操作手册

全面介绍Python四大核心数据结构的使用方法、最佳实践和应用场景，帮助开发者选择合适的数据结构。

2025-01-23约 13 分钟阅读Yaron
#Python#数据结构#Python3.8+

快速概览：四大数据结构对比

特性列表 (List)元组 (Tuple)字典 (Dict)集合 (Set)
英文名listtupledictset
定义符号[ ]( ){ }{ } 或 set()
有序性有序有序有序 (Python 3.7+)无序
可变性可变 (Mutable)不可变 (Immutable)可变 (Mutable)可变 (Mutable)
元素唯一性元素可重复元素可重复键 (Key) 唯一元素唯一
核心用途存储有序、可变的数据序列存储有序、不可变的数据存储键值对映射关系存储唯一元素，进行数学运算

一、 列表 (List)

列表是 Python 中最通用、最灵活的数据结构。它是一个有序且可变的元素序列。

1. 创建 (Create)

# 1. 直接使用 []  
my_list = [1, "hello", 3.14, True]

# 2. 使用 list() 构造函数  
empty_list = list()  
list_from_tuple = list((1, 2, 3)) # 从元组创建

# 3. 列表推导式 (List Comprehension) - 强烈推荐  
# x**2 是 Python 中的幂运算（exponentiation）语法，表示 x 的 2 次方
squares = [x**2 for x in range(5)] # -> [0, 1, 4, 9, 16]

2. 增删改查 (CRUD)

  • 增 (Add)

    • append(x): 在列表末尾添加一个元素。 
      my_list.append("new")

    • insert(i, x): 在指定索引 i 处插入一个元素。

      # 在索引1处插入
my_list.insert(1, "world")

    • extend(iterable): 用另一个可迭代对象（如另一个列表）来扩展列表。

      my_list.extend([4, 5])

  • 删 (Delete)

    • remove(x): 删除第一个值为 x 的元素。如果元素不存在会报错 ValueError。

      my_list.remove("hello")

    • pop(i): 删除并返回指定索引 i 处的元素。如果省略 i，则默认删除并返回最后一个元素。

      # 删除第一个元素  
popped_item = my_list.pop(0) 
# 删除最后一个元素
last_item = my_list.pop()

    • del my_list[i]: 使用 del 关键字删除指定索引的元素或切片。

      del my_list[0]

    • clear(): 清空列表中的所有元素。

      my_list.clear()

  • 改 (Update)

    • 通过索引直接赋值。 
      my_list = [1, 2, 3]  
# 修改后-> [100, 2, 3]
my_list[0] = 100

  • 查 (Read)

    • 索引: my_list[i] 获取单个元素（支持负索引，-1为最后一个元素）。
    • 切片: my_list[start:stop:step] 获取子列表。
    • 查找:
      • in: 判断元素是否存在。"hello" in my_list
      • index(x): 返回第一个值为 x 的元素的索引。不存在则报错。
      • count(x): 返回元素 x 出现的次数。

3. 遍历 (Iteration)

data = ["apple", "banana", "cherry"]

# 1. 直接遍历元素 (最常用)  
for fruit in data:  
    print(fruit)

# 2. 通过索引遍历  
for i in range(len(data)):  
    print(f"Index {i}: {data[i]}")

# 3. 同时遍历索引和元素 (推荐)  
for i, fruit in enumerate(data):  
    print(f"Index {i}: {fruit}")

4. 最佳实践与应用场景

二、 元组 (Tuple)

元组是一个有序但不可变的元素序列。一旦创建，就不能修改。

1. 创建 (Create)

# 1. 直接使用 ()
my_tuple = (1, "hello", 3.14)

# 2. 使用 tuple() 构造函数
empty_tuple = tuple()
tuple_from_list = tuple([1, 2, 3])

# 3. 特别注意：单个元素的元组
single_tuple = (1,)  # 必须有逗号！(1) 会被解释为整数 1

2. 增删改查 (CRUD)

  • 增 (Add): 不可行。
  • 删 (Delete): 不可行。
  • 改 (Update): 不可行。

核心思想：你不能修改元组本身，但可以创建一个包含所需更改的新元组。

t1 = (1, 2, 3)
t2 = t1 + (4, 5)  # 创建新元组 t2 -> (1, 2, 3, 4, 5)
  • 查 (Read)
    • 与列表完全相同：支持索引、切片、in、index()、count()。

3. 遍历 (Iteration)

与列表的遍历方法完全相同。

4. 最佳实践与应用场景

  • 当你需要保护数据，确保它在程序运行期间不被意外修改时。
  • 作为字典的键（因为键必须是不可变类型）。
  • 当函数需要返回多个值时，打包成元组返回是一种常见且优雅的做法。return x, y
  • 存储固定集合的数据，如坐标 (x, y)，或数据库记录。
  • 性能上，元组通常比列表占用更少的内存，处理速度也略快。

三、 字典 (Dict)

字典是一个有序（在 Python 3.7+ 版本中为有序）的键值对 (key-value) 集合。键必须是唯一的、不可变的类型。

1. 创建 (Create)

# 1. 直接使用 {}
my_dict = {"name": "Alice", "age": 25}

# 2. 使用 dict() 构造函数
empty_dict = dict()
dict_from_kwargs = dict(name="Bob", age=30)
dict_from_list_of_tuples = dict([('name', 'Charlie'), ('age', 40)])

# 3. 字典推导式 (Dictionary Comprehension)
squares_dict = {x: x**2 for x in range(5)}  # -> {0:0, 1:1, 2:4, 3:9, 4:16}

2. 增删改查 (CRUD)

  • 增 (Add) / 改 (Update)

    • 如果键已存在，则更新值；如果不存在，则创建新的键值对。 
      my_dict["age"] = 26      # 更新
my_dict["city"] = "New York"  # 新增
    • update(other_dict): 用另一个字典来更新当前字典。 
      my_dict.update({"gender": "female", "city": "Boston"})

  • 删 (Delete)

    • pop(key): 删除并返回指定键的值。如果键不存在会报错 KeyError。
    • popitem(): (Python 3.7+) 删除并返回最后插入的键值对（LIFO）。
    • del my_dict[key]: 删除指定的键值对。
    • clear(): 清空字典。

  • 查 (Read)

    • my_dict[key]: 通过键获取值。如果键不存在会报错 KeyError。
    • get(key, default=None): 强烈推荐！通过键获取值，如果键不存在，返回 default 值（默认为 None），不会报错。 
      name = my_dict.get("name")
country = my_dict.get("country", "Unknown")  # 安全的访问

3. 遍历 (Iteration)

my_dict = {"name": "Alice", "age": 25}

# 1. 遍历键 (默认行为)
for key in my_dict:
    print(key)  # "name", "age"

# 2. 遍历值
for value in my_dict.values():
    print(value)  # "Alice", 25

# 3. 同时遍历键和值 (最常用)
for key, value in my_dict.items():
    print(f"{key}: {value}")

4. 最佳实践与应用场景

  • 当你需要通过唯一的标识符（键）来快速查找、存储和管理数据时。
  • 表示现实世界中的对象或结构化数据，例如一个用户的属性、一本书的信息。
  • 作为替代 if-elif-else 或 switch-case 的一种高效方式。
  • 处理 JSON 数据（JSON 对象和 Python 字典可以无缝转换）。

四、 集合 (Set)

集合是一个无序、不重复的元素集合。主要用于成员测试和数学运算。

1. 创建 (Create)

# 1. 直接使用 {}
my_set = {1, 2, 3, "hello", 1}  # 重复的 1 会被自动忽略 -> {1, 2, 3, 'hello'}

# 2. 使用 set() 构造函数 (创建空集合的唯一方法)
empty_set = set()  # 注意：{} 创建的是空字典！
set_from_list = set([1, 2, 2, 3])  # -> {1, 2, 3}

# 3. 集合推导式 (Set Comprehension)
unique_squares = {x**2 for x in [-1, 1, 2, -2]}  # -> {1, 4}

2. 增删改查 (CRUD)

  • 增 (Add)

    • add(x): 添加一个元素。
    • update(iterable): 用另一个可迭代对象来更新集合。

  • 删 (Delete)

    • remove(x): 删除元素 x。如果 x 不存在，会报错 KeyError。
    • discard(x): 推荐！删除元素 x。如果 x 不存在，什么也不做，不会报错。
    • pop(): 随机删除并返回一个元素。
    • clear(): 清空集合。

  • 改 (Update): 不可行。集合中的元素是不可变的，你不能修改单个元素，只能添加或删除。

  • 查 (Read):

    • in: 效率极高的成员资格测试。是集合最核心的优势之一。 
      is_present = "hello" in my_set

3. 数学运算 (核心功能)

a = {1, 2, 3}
b = {3, 4, 5}

# 并集 (Union)
print(a | b)  # -> {1, 2, 3, 4, 5}
print(a.union(b))

# 交集 (Intersection)
print(a & b)  # -> {3}
print(a.intersection(b))

# 差集 (Difference)
print(a - b)  # -> {1, 2} (在 a 中但不在 b 中)
print(a.difference(b))

# 对称差集 (Symmetric Difference)
print(a ^ b)  # -> {1, 2, 4, 5} (只在 a 或只在 b 中，但不同时在两者中)
print(a.symmetric_difference(b))

4. 遍历 (Iteration)

与列表类似，但请记住，遍历的顺序是不保证的。

for item in my_set:
    print(item)

5. 最佳实践与应用场景

  • 对列表或任何序列进行快速去重。
  • 需要高效地检查一个元素是否存在于一个大的集合中时。
  • 当你需要进行并集、交集、差集等数学集合运算时。